home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1999 March / EnigmA AMIGA RUN 35 (1999)(G.R. Edizioni)(IT)[!][issue 1999-03].iso / earcd / grafica / amhelios / ray_rad.cpp < prev    next >
C/C++ Source or Header  |  1999-01-01  |  7KB  |  224 lines
  1. ////////////////////////////////////////////////////////////
  2. //
  3. //  RAY_RAD.CPP - Ray Casting Radiosity Class
  4. //
  5. //  Version:    1.03A
  6. //
  7. //  History:    94/08/23 - Version 1.00A release.
  8. //              94/09/24 - Modified Open function.
  9. //              94/11/24 - Modified Calculate and AddAmbient
  10. //                         functions.
  11. //              94/12/16 - Version 1.01A release.
  12. //              95/02/05 - Version 1.02A release.
  13. //              95/07/16 - Removed ambient exitance addition
  14. //                         from Calculate function.
  15. //              95/07/21 - Version 1.02B release.
  16. //              96/02/14 - Version 1.02C release.
  17. //              96/04/01 - Version 1.03A release.
  18. //
  19. //  Compilers:  Microsoft Visual C/C++ Professional V1.5
  20. //              Borland C++ Version 4.5
  21. //
  22. //  Author:     Ian Ashdown, P.Eng.
  23. //              byHeart Software Limited
  24. //              620 Ballantree Road
  25. //              West Vancouver, B.C.
  26. //              Canada V7S 1W3
  27. //              Tel. (604) 922-6148
  28. //              Fax. (604) 987-7621
  29. //
  30. //  Copyright 1994-1996 byHeart Software Limited
  31. //
  32. //  The following source code has been derived from:
  33. //
  34. //    Ashdown, I. 1994. Radiosity: A Programmer's
  35. //    Perspective. New York, NY: John Wiley & Sons.
  36. //
  37. //  It may be freely copied, redistributed, and/or modified
  38. //  for personal use ONLY, as long as the copyright notice
  39. //  is included with all source code files.
  40. //
  41. ////////////////////////////////////////////////////////////
  42.  
  43. #include "ray_rad.h"
  44.  
  45. // Open ray casting radiosity renderer
  46. BOOL RayRad::Open( Environ *pe )
  47. {
  48.   penv = pe;            // Save environment pointer
  49.   step_count = 0;       // Reset step count
  50.   convergence = 1.0;    // Convergence
  51.   start = clock();      // Initialize start time
  52.   InitExitance();       // Initialize exitances
  53.  
  54.   if (amb_flag == TRUE) // Ambient exitance required ?
  55.   {
  56.     CalcInterReflect(); // Calculate interreflection factor
  57.     CalcAmbient();      // Calculate initial ambient term
  58.   }
  59.  
  60.   return TRUE;
  61. } 
  62.  
  63. // Calculate element exitances
  64. BOOL RayRad::Calculate()
  65. {
  66.   int i;                // Loop index
  67.   int num_vert;         // Number of element vertices
  68.   float vsff;           // Vertex-to-source form factor
  69.   BOOL self;            // Self patch flag
  70.   Element3 *pelem;      // Element pointer
  71.   Instance *pinst;      // Instance pointer
  72.   Patch3 *ppatch;       // Patch pointer
  73.   Surface3 *psurf;      // Surface pointer
  74.   Spectra p_delta;      // Patch delta exitance
  75.   Spectra v_delta;      // Vertex delta exitance
  76.   Spectra reflect;      // Surface reflectance
  77.   Spectra shoot;        // Shoot exitance
  78.   Vertex3 *pvert;       // Vertex pointer
  79.  
  80.   // Check for maximum number of steps
  81.   if (step_count >= max_step)
  82.     return TRUE;
  83.  
  84.   UpdateUnsentStats();  // Update unsent flux statistics
  85.  
  86.   // Check for convergence
  87.   if (convergence < stop_criterion)
  88.     return TRUE;
  89.  
  90.   // Initialize form factor determination object
  91.   ffd.Init(pmax);
  92.  
  93.   // Walk the instance list
  94.   pinst = penv->GetInstPtr();
  95.   while (pinst != NULL)
  96.   {
  97.     // Walk the surface list
  98.     psurf = pinst->GetSurfPtr();
  99.     while (psurf != NULL)
  100.     {
  101.       // Get surface reflectance
  102.       reflect = psurf->GetReflectance();
  103.  
  104.       // Walk the patch list
  105.       ppatch = psurf->GetPatchPtr();
  106.       while (ppatch != NULL)
  107.       {
  108.         // Check for self patch
  109.         self = (ppatch == pmax) ? TRUE : FALSE;
  110.  
  111.         // Walk the element list
  112.         pelem = ppatch->GetElementPtr();
  113.         while (pelem != NULL)
  114.         {
  115.           if (self == FALSE)    // Ignore self
  116.           {
  117.             // Get shooting patch unsent exitance
  118.             shoot = pmax->GetExitance();
  119.  
  120.             // Reset patch delta exitance
  121.             p_delta.Reset();
  122.  
  123.             num_vert = pelem->GetNumVert();
  124.             for (i = 0; i < num_vert; i++)
  125.             {
  126.               // Get element vertex pointer
  127.               pvert = pelem->GetVertexPtr(i);
  128.  
  129.               // Get vertex-to-source form factor
  130.               if ((vsff = (float) ffd.CalcFormFactor(pvert,
  131.                   penv->GetInstPtr())) > 0.0)
  132.               {
  133.                 // Calculate vertex delta exitance
  134.                 v_delta = Mult(reflect, shoot);
  135.                 v_delta.Scale(vsff);
  136.  
  137.                 // Update vertex exitance
  138.                 pvert->GetExitance().Add(v_delta);
  139.  
  140.                 // Update patch delta exitance
  141.                 p_delta.Add(v_delta);
  142.               }
  143.             }
  144.  
  145.             // Update patch unsent exitance
  146.             p_delta.Scale(pelem->GetArea() / ((double)
  147.                 num_vert * ppatch->GetArea()));
  148.             ppatch->GetExitance().Add(p_delta);
  149.           }
  150.           pelem = pelem->GetNext();
  151.         }
  152.         ppatch = ppatch->GetNext();
  153.       }
  154.       psurf = psurf->GetNext();
  155.     }
  156.     pinst = pinst->GetNext();
  157.   }
  158.  
  159.   // Reset unsent exitance to zero
  160.   pmax->GetExitance().Reset();
  161.  
  162.   if (amb_flag == TRUE)
  163.   {
  164.     CalcAmbient();      // Recalculate ambient exitance
  165.   }
  166.  
  167.   step_count++;         // Increment step count
  168.   return FALSE;         // Convergence not achieved yet
  169. }
  170.  
  171. void RayRad::AddAmbient()       // Add ambient exitance
  172. {
  173.   int i;                // Loop index
  174.   int num_vert;         // Number of element vertices
  175.   Element3 *pelem;      // Element pointer
  176.   Instance *pinst;      // Instance pointer
  177.   Patch3 *ppatch;       // Patch pointer
  178.   Spectra delta_amb;    // Delta ambient exitance
  179.   Spectra reflect;      // Surface reflectance
  180.   Surface3 *psurf;      // Surface pointer
  181.   Vertex3 *pvert;       // Vertex pointer
  182.  
  183.   // Walk the instance list
  184.   pinst = penv->GetInstPtr();
  185.   while (pinst != NULL)
  186.   {
  187.     // Walk the surface list
  188.     psurf = pinst->GetSurfPtr();
  189.     while (psurf != NULL)
  190.     {
  191.       // Get surface reflectance
  192.       reflect = psurf->GetReflectance();
  193.  
  194.       // Walk the patch list
  195.       ppatch = psurf->GetPatchPtr();
  196.       while (ppatch != NULL)
  197.       {
  198.         // Walk the element list
  199.         pelem = ppatch->GetElementPtr();
  200.         while (pelem != NULL)
  201.         {
  202.           // Calculate delta ambient exitance
  203.           delta_amb = Mult(ambient, reflect);
  204.  
  205.           num_vert = pelem->GetNumVert();
  206.           for (i = 0; i < num_vert; i++)
  207.           {
  208.             // Get element vertex pointer
  209.             pvert = pelem->GetVertexPtr(i);
  210.  
  211.             // Update vertex exitance
  212.             pvert->GetExitance().Add(delta_amb);
  213.           }
  214.           pelem = pelem->GetNext();
  215.         }
  216.         ppatch = ppatch->GetNext();
  217.       }
  218.       psurf = psurf->GetNext();
  219.     }
  220.     pinst = pinst->GetNext();
  221.   }
  222. }
  223.  
  224.